/*
 * Copyright (c) 2015-2017, Armink, <armink.ztl@gmail.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 * 'Software'), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 * Function: Save logs to flash.
 * Created on: 2015-06-04
 */

#include <easyflash.h>

#ifdef EF_USING_LOG

/* magic code on every sector header. 'EF' is 0x4546 */
#define LOG_SECTOR_MAGIC               0x4546
/* sector header size, include the sector magic code and status magic code */
#define LOG_SECTOR_HEADER_SIZE         4

/**
 * Sector status magic code
 * The sector status is 16-Bits after LOG_SECTOR_MAGIC at every sector header.
 * =======================
 * | header(4B) | status |
 * -----------------------
 * | 0x4546FFFF |  empty |
 * | 0x4546FFFE |  using |
 * | 0x4546FFFC |  full  |
 * =======================
 *
 * State transition relationship: empty->using->full
 * The FULL status will change to EMPTY after sector clean.
 */
enum {
	SECTOR_STATUS_MAGIC_EMPUT = 0xFFFF,
	SECTOR_STATUS_MAGIC_USING = 0xFFFE,
	SECTOR_STATUS_MAGIC_FULL = 0xFFFC,
};

typedef enum {
	SECTOR_STATUS_EMPUT,
	SECTOR_STATUS_USING,
	SECTOR_STATUS_FULL,
	SECTOR_STATUS_HEADER_ERROR,
} SectorStatus;

/* the stored logs start address and end address. It's like a ring buffer which implement by flash. */
static uint32_t log_start_addr = 0, log_end_addr = 0;
/* saved log area address for flash */
static uint32_t log_area_start_addr = 0;
/* initialize OK flag */
static bool init_ok = false;

static void find_start_and_end_addr(void);
static uint32_t get_next_flash_sec_addr(uint32_t cur_addr);

/**
 * The flash save log function initialize.
 *
 * @return result
 */
EfErrCode ef_log_init(void)
{
	EfErrCode result = EF_NO_ERR;

	EF_ASSERT(LOG_AREA_SIZE);
	EF_ASSERT(EF_ERASE_MIN_SIZE);
	/* the log area size must be an integral multiple of erase minimum size. */
	EF_ASSERT(LOG_AREA_SIZE % EF_ERASE_MIN_SIZE == 0);
	/* the log area size must be more than twice of EF_ERASE_MIN_SIZE */
	EF_ASSERT(LOG_AREA_SIZE / EF_ERASE_MIN_SIZE >= 2);

#ifdef EF_USING_ENV
	log_area_start_addr = EF_START_ADDR + ENV_AREA_SIZE;
#else
	log_area_start_addr = EF_START_ADDR;
#endif

	/* find the log store start address and end address */
	find_start_and_end_addr();
	/* initialize OK */
	init_ok = true;

	return result;
}

/**
 * Get flash sector current status.
 *
 * @param addr sector address, this function will auto calculate the sector header address by this address.
 *
 * @return the flash sector current status
 */
static SectorStatus get_sector_status(uint32_t addr)
{
	uint32_t header = 0, header_addr = 0;
	uint16_t sector_magic = 0, status_magic = 0;

	/* calculate the sector header address */
	header_addr = addr / EF_ERASE_MIN_SIZE * EF_ERASE_MIN_SIZE;

	if (ef_port_read(header_addr, &header, sizeof(header)) == EF_NO_ERR) {
		sector_magic = header >> 16;
		status_magic = header;
	} else {
		EF_DEBUG("Error: Read sector header data error.\n");
		return SECTOR_STATUS_HEADER_ERROR;
	}
	/* compare header magic code */
	if (sector_magic == LOG_SECTOR_MAGIC) {
		switch (status_magic) {
		case SECTOR_STATUS_MAGIC_EMPUT:
			return SECTOR_STATUS_EMPUT;
		case SECTOR_STATUS_MAGIC_USING:
			return SECTOR_STATUS_USING;
		case SECTOR_STATUS_MAGIC_FULL:
			return SECTOR_STATUS_FULL;
		default:
			return SECTOR_STATUS_HEADER_ERROR;
		}
	} else
		return SECTOR_STATUS_HEADER_ERROR;
}

/**
 * Write flash sector current status.
 *
 * @param addr sector address, this function will auto calculate the sector header address by this address.
 * @param status sector cur status
 *
 * @return result
 */
static EfErrCode write_sector_status(uint32_t addr, SectorStatus status)
{
	uint32_t header = 0, header_addr = 0;
	uint16_t status_magic;

	/* calculate the sector header address */
	header_addr = addr / EF_ERASE_MIN_SIZE * EF_ERASE_MIN_SIZE;

	switch (status) {
	case SECTOR_STATUS_EMPUT: {
		status_magic = SECTOR_STATUS_MAGIC_EMPUT;
		break;
	}
	case SECTOR_STATUS_USING: {
		status_magic = SECTOR_STATUS_MAGIC_USING;
		break;
	}
	case SECTOR_STATUS_FULL: {
		status_magic = SECTOR_STATUS_MAGIC_FULL;
		break;
	}
	}
	header = (LOG_SECTOR_MAGIC << 16) | status_magic;

	return ef_port_write(header_addr, &header, sizeof(header));
}

/**
 * Find the current flash sector using end address by continuous 0xFF.
 *
 * @param addr sector address
 *
 * @return current flash sector using end address
 */
static uint32_t find_sec_using_end_addr(uint32_t addr)
{
	/* read section data buffer size */
#define READ_BUF_SIZE                32

	uint32_t sector_start = addr, data_start = addr, continue_ff = 0, read_buf_size = 0, i;
	uint8_t buf[READ_BUF_SIZE];

	EF_ASSERT(READ_BUF_SIZE % 4 == 0);
	/* calculate the sector start and data start address */
	sector_start = addr / EF_ERASE_MIN_SIZE * EF_ERASE_MIN_SIZE;
	data_start = sector_start + LOG_SECTOR_HEADER_SIZE;

	/* counts continuous 0xFF which is end of sector */
	while (data_start < sector_start + EF_ERASE_MIN_SIZE) {
		if (data_start + READ_BUF_SIZE < sector_start + EF_ERASE_MIN_SIZE)
			read_buf_size = READ_BUF_SIZE;
		else
			read_buf_size = sector_start + EF_ERASE_MIN_SIZE - data_start;
		ef_port_read(data_start, (uint32_t *)buf, read_buf_size);
		for (i = 0; i < read_buf_size; i++) {
			if (buf[i] == 0xFF)
				continue_ff++;
			else
				continue_ff = 0;
		}
		data_start += read_buf_size;
	}
	/* calculate current flash sector using end address */
	if (continue_ff >= EF_ERASE_MIN_SIZE - LOG_SECTOR_HEADER_SIZE) {
		/* from 0 to sec_size all sector is 0xFF, so the sector is empty */
		return sector_start + LOG_SECTOR_HEADER_SIZE;
	} else if (continue_ff >= 4) {
		/* form end_addr - 4 to sec_size length all area is 0xFF, so it's used part of the sector.
		 * the address must be word alignment. */
		if (continue_ff % 4 != 0)
			continue_ff = (continue_ff / 4 + 1) * 4;
		return sector_start + EF_ERASE_MIN_SIZE - continue_ff;
	} else {
		/* all sector not has continuous 0xFF, so the sector is full */
		return sector_start + EF_ERASE_MIN_SIZE;
	}
}

/**
 * Find the log store start address and end address.
 * It's like a ring buffer which implement by flash.
 * The flash log area has two state when find start address and end address.
 *                       state 1                                state 2
 *                   |============|                         |============|
 * log area start--> |############| <-- start address       |############| <-- end address
 *                   |############|                         |   empty    |
 *                   |------------|                         |------------|
 *                   |############|                         |############| <-- start address
 *                   |############|                         |############|
 *                   |------------|                         |------------|
 *                   |     .      |                         |     .      |
 *                   |     .      |                         |     .      |
 *                   |     .      |                         |     .      |
 *                   |------------|                         |------------|
 *                   |############| <-- end address         |############|
 *                   |   empty    |                         |############|
 *  log area end --> |============|                         |============|
 *
 *  LOG_AREA_SIZE = log area end - log area star
 *
 */
static void find_start_and_end_addr(void)
{
	size_t cur_size = 0;
	SectorStatus cur_sec_status, last_sec_status;
	uint32_t cur_using_sec_addr = 0;
	/* all status sector counts */
	size_t empty_sec_counts = 0, using_sec_counts = 0, full_sector_counts = 0;
	/* total sector number */
	size_t total_sec_num = LOG_AREA_SIZE / EF_ERASE_MIN_SIZE;
	/* see comment of find_start_and_end_addr function */
	uint8_t cur_log_sec_state = 0;

	/* get the first sector status */
	cur_sec_status = get_sector_status(log_area_start_addr);
	last_sec_status = cur_sec_status;

	for (cur_size = EF_ERASE_MIN_SIZE; cur_size < LOG_AREA_SIZE; cur_size += EF_ERASE_MIN_SIZE) {
		/* get current sector status */
		cur_sec_status = get_sector_status(log_area_start_addr + cur_size);
		/* compare last and current status */
		switch (last_sec_status) {
		case SECTOR_STATUS_EMPUT: {
			switch (cur_sec_status) {
			case SECTOR_STATUS_EMPUT:
				break;
			case SECTOR_STATUS_USING:
				EF_DEBUG("Error: Log area error! Now will clean all log area.\n");
				ef_log_clean();
				return;
			case SECTOR_STATUS_FULL:
				EF_DEBUG("Error: Log area error! Now will clean all log area.\n");
				ef_log_clean();
				return;
			}
			empty_sec_counts++;
			break;
		}
		case SECTOR_STATUS_USING: {
			switch (cur_sec_status) {
			case SECTOR_STATUS_EMPUT:
				/* like state 1 */
				cur_log_sec_state = 1;
				log_start_addr = log_area_start_addr;
				cur_using_sec_addr = log_area_start_addr + cur_size - EF_ERASE_MIN_SIZE;
				break;
			case SECTOR_STATUS_USING:
				EF_DEBUG("Error: Log area error! Now will clean all log area.\n");
				ef_log_clean();
				return;
			case SECTOR_STATUS_FULL:
				/* like state 2 */
				cur_log_sec_state = 2;
				log_start_addr = log_area_start_addr + cur_size;
				cur_using_sec_addr = log_area_start_addr + cur_size - EF_ERASE_MIN_SIZE;
				break;
			}
			using_sec_counts++;
			break;
		}
		case SECTOR_STATUS_FULL: {
			switch (cur_sec_status) {
			case SECTOR_STATUS_EMPUT:
				/* like state 1 */
				if (cur_log_sec_state == 2) {
					EF_DEBUG("Error: Log area error! Now will clean all log area.\n");
					ef_log_clean();
					return;
				} else {
					cur_log_sec_state = 1;
					log_start_addr = log_area_start_addr;
					log_end_addr = log_area_start_addr + cur_size;
					cur_using_sec_addr = log_area_start_addr + cur_size - EF_ERASE_MIN_SIZE;
				}
				break;
			case SECTOR_STATUS_USING:
				if (total_sec_num <= 2) {
					/* like state 1 */
					cur_log_sec_state = 1;
					log_start_addr = log_area_start_addr;
					cur_using_sec_addr = log_area_start_addr + cur_size;
				} else {
					/* like state 2 when the sector is the last one */
					if (cur_size + EF_ERASE_MIN_SIZE >= LOG_AREA_SIZE) {
						cur_log_sec_state = 2;
						log_start_addr = log_area_start_addr + cur_size;
						cur_using_sec_addr = log_area_start_addr + cur_size - EF_ERASE_MIN_SIZE;
					}
				}
				break;
			case SECTOR_STATUS_FULL:
				break;
			}
			full_sector_counts++;
			break;
		}
		case SECTOR_STATUS_HEADER_ERROR:
			EF_DEBUG("Error: Log sector header error! Now will clean all log area.\n");
			ef_log_clean();
			return;
		}
		last_sec_status = cur_sec_status;
	}

	/* the last sector status counts */
	if (cur_sec_status == SECTOR_STATUS_EMPUT)
		empty_sec_counts++;
	else if (cur_sec_status == SECTOR_STATUS_USING)
		using_sec_counts++;
	else if (cur_sec_status == SECTOR_STATUS_FULL)
		full_sector_counts++;
	else if (cur_sec_status == SECTOR_STATUS_HEADER_ERROR) {
		EF_DEBUG("Error: Log sector header error! Now will clean all log area.\n");
		ef_log_clean();
		return;
	}

	if (using_sec_counts != 1) {
		/* this state is almost impossible */
		EF_DEBUG("Error: There must be only one sector status is USING! Now will clean all log area.\n");
		ef_log_clean();
	} else {
		/* find the end address */
		log_end_addr = find_sec_using_end_addr(cur_using_sec_addr);
	}
}

/**
 * Get log used flash total size.
 *
 * @return log used flash total size. @note NOT contain sector headers
 */
size_t ef_log_get_used_size(void)
{
	size_t header_total_num = 0, physical_size = 0;
	/* must be call this function after initialize OK */
	if (!init_ok)
		return 0;

	if (log_start_addr < log_end_addr)
		physical_size = log_end_addr - log_start_addr;
	else
		physical_size = LOG_AREA_SIZE - (log_start_addr - log_end_addr);

	header_total_num = physical_size / EF_ERASE_MIN_SIZE + 1;

	return physical_size - header_total_num * LOG_SECTOR_HEADER_SIZE;
}

/**
 * Sequential reading log data. It will ignore sector headers.
 *
 * @param addr address
 * @param log log buffer
 * @param size log size, not contain sector headers.
 *
 * @return result
 */
static EfErrCode log_seq_read(uint32_t addr, uint32_t *log, size_t size)
{
	EfErrCode result = EF_NO_ERR;
	size_t read_size = 0, read_size_temp = 0;

	while (size) {
		/* move to sector data address */
		if ((addr + read_size) % EF_ERASE_MIN_SIZE == 0)
			addr += LOG_SECTOR_HEADER_SIZE;
		/* calculate current sector last data size */
		read_size_temp = EF_ERASE_MIN_SIZE - (addr % EF_ERASE_MIN_SIZE);
		if (size < read_size_temp)
			read_size_temp = size;
		result = ef_port_read(addr + read_size, log + read_size / 4, read_size_temp);
		if (result != EF_NO_ERR)
			return result;
		read_size += read_size_temp;
		size -= read_size_temp;
	}

	return result;
}

/**
 * Calculate flash physical address by log index.
 *
 * @param index log index
 *
 * @return flash physical address
 */
static uint32_t log_index2addr(size_t index)
{
	size_t header_total_offset = 0;
	/* total include sector number */
	size_t sector_num = index / (EF_ERASE_MIN_SIZE - LOG_SECTOR_HEADER_SIZE) + 1;

	header_total_offset = sector_num * LOG_SECTOR_HEADER_SIZE;
	if (log_start_addr < log_end_addr)
		return log_start_addr + index + header_total_offset;
	else {
		if (log_start_addr + index + header_total_offset < log_area_start_addr + LOG_AREA_SIZE)
			return log_start_addr + index + header_total_offset;
		else
			return log_start_addr + index + header_total_offset - LOG_AREA_SIZE;

	}
}

/**
 * Read log from flash.
 *
 * @param index index for saved log.
 *        Minimum index is 0.
 *        Maximum index is ef_log_get_used_size() - 1.
 * @param log the log which will read from flash
 * @param size read bytes size
 *
 * @return result
 */
EfErrCode ef_log_read(size_t index, uint32_t *log, size_t size)
{
	EfErrCode result = EF_NO_ERR;
	size_t cur_using_size = ef_log_get_used_size();
	size_t read_size_temp = 0;
	size_t header_total_num = 0;

	if (!size)
		return result;

	EF_ASSERT(size % 4 == 0);
	EF_ASSERT(index < cur_using_size);

	if (index + size > cur_using_size) {
		EF_DEBUG("Warning: Log read size out of bound. Cut read size.\n");
		size = cur_using_size - index;
	}
	/* must be call this function after initialize OK */
	if (!init_ok)
		return EF_ENV_INIT_FAILED;

	if (log_start_addr < log_end_addr)
		log_seq_read(log_index2addr(index), log, size);
	else {
		if (log_index2addr(index) + size <= log_area_start_addr + LOG_AREA_SIZE) {
			/*                          Flash log area
			 *                         |--------------|
			 * log_area_start_addr --> |##############|
			 *                         |##############|
			 *                         |##############|
			 *                         |--------------|
			 *                         |##############|
			 *                         |##############|
			 *                         |##############| <-- log_end_addr
			 *                         |--------------|
			 *      log_start_addr --> |##############|
			 *          read start --> |**************| <-- read end
			 *                         |##############|
			 *                         |--------------|
			 *
			 * read from (log_start_addr + log_index2addr(index)) to (log_start_addr + index + log_index2addr(index))
			 */
			result = log_seq_read(log_index2addr(index), log, size);
		} else if (log_index2addr(index) < log_area_start_addr + LOG_AREA_SIZE) {
			/*                          Flash log area
			 *                         |--------------|
			 * log_area_start_addr --> |**************| <-- read end
			 *                         |##############|
			 *                         |##############|
			 *                         |--------------|
			 *                         |##############|
			 *                         |##############|
			 *                         |##############| <-- log_end_addr
			 *                         |--------------|
			 *      log_start_addr --> |##############|
			 *          read start --> |**************|
			 *                         |**************|
			 *                         |--------------|
			 * read will by 2 steps
			 * step1: read from (log_start_addr + log_index2addr(index)) to flash log area end address
			 * step2: read from flash log area start address to read size's end address
			 */
			read_size_temp = (log_area_start_addr + LOG_AREA_SIZE) - log_index2addr(index);
			header_total_num = read_size_temp / EF_ERASE_MIN_SIZE;
			/* Minus some ignored bytes */
			read_size_temp -= header_total_num * LOG_SECTOR_HEADER_SIZE;
			result = log_seq_read(log_index2addr(index), log, read_size_temp);
			if (result == EF_NO_ERR)
				result = log_seq_read(log_area_start_addr, log + read_size_temp / 4, size - read_size_temp);
		} else {
			/*                          Flash log area
			 *                         |--------------|
			 * log_area_start_addr --> |##############|
			 *          read start --> |**************|
			 *                         |**************| <-- read end
			 *                         |--------------|
			 *                         |##############|
			 *                         |##############|
			 *                         |##############| <-- log_end_addr
			 *                         |--------------|
			 *      log_start_addr --> |##############|
			 *                         |##############|
			 *                         |##############|
			 *                         |--------------|
			 * read from (log_start_addr + log_index2addr(index) - LOG_AREA_SIZE) to read size's end address
			 */
			result = log_seq_read(log_index2addr(index) - LOG_AREA_SIZE, log, size);
		}
	}

	return result;
}

/**
 * Write log to flash.
 *
 * @param log the log which will be write to flash
 * @param size write bytes size
 *
 * @return result
 */
EfErrCode ef_log_write(const uint32_t *log, size_t size)
{
	EfErrCode result = EF_NO_ERR;
	size_t write_size = 0, writable_size = 0;
	uint32_t write_addr = log_end_addr, erase_addr;
	SectorStatus sector_status;

	EF_ASSERT(size % 4 == 0);
	/* must be call this function after initialize OK */
	if (!init_ok)
		return EF_ENV_INIT_FAILED;

	if ((sector_status = get_sector_status(write_addr)) == SECTOR_STATUS_HEADER_ERROR)
		return EF_WRITE_ERR;
	/* write some log when current sector status is USING and EMPTY */
	if ((sector_status == SECTOR_STATUS_USING) || (sector_status == SECTOR_STATUS_EMPUT)) {
		/* write the already erased but not used area */
		writable_size = EF_ERASE_MIN_SIZE - ((write_addr - log_area_start_addr) % EF_ERASE_MIN_SIZE);
		if (size >= writable_size) {
			result = ef_port_write(write_addr, log, writable_size);
			if (result != EF_NO_ERR)
				goto exit;
			/* change the current sector status to FULL */
			result = write_sector_status(write_addr, SECTOR_STATUS_FULL);
			if (result != EF_NO_ERR)
				goto exit;
			write_size += writable_size;
		} else {
			result = ef_port_write(write_addr, log, size);
			log_end_addr = write_addr + size;
			goto exit;
		}
	}
	/* erase and write remain log */
	while (true) {
		/* calculate next available sector address */
		erase_addr = write_addr = get_next_flash_sec_addr(write_addr - 4);
		/* move the flash log start address to next available sector address */
		if (log_start_addr == erase_addr)
			log_start_addr = get_next_flash_sec_addr(log_start_addr);
		/* erase sector */
		result = ef_port_erase(erase_addr, EF_ERASE_MIN_SIZE);
		if (result != EF_NO_ERR)
			goto exit;
		/* change the sector status to USING when write begin sector start address */
		result = write_sector_status(write_addr, SECTOR_STATUS_USING);
		if (result == EF_NO_ERR)
			write_addr += LOG_SECTOR_HEADER_SIZE;
		else
			goto exit;
		/* calculate current sector writable data size */
		writable_size = EF_ERASE_MIN_SIZE - LOG_SECTOR_HEADER_SIZE;
		if (size - write_size >= writable_size) {
			result = ef_port_write(write_addr, log + write_size / 4, writable_size);
			if (result != EF_NO_ERR)
				goto exit;
			/* change the current sector status to FULL */
			result = write_sector_status(write_addr, SECTOR_STATUS_FULL);
			if (result != EF_NO_ERR)
				goto exit;
			log_end_addr = write_addr + writable_size;
			write_size += writable_size;
			write_addr += writable_size;
		} else {
			result = ef_port_write(write_addr, log + write_size / 4, size - write_size);
			if (result != EF_NO_ERR)
				goto exit;
			log_end_addr = write_addr + (size - write_size);
			break;
		}
	}

exit:
	return result;
}

/**
 * Get next flash sector address.The log total sector like ring buffer which implement by flash.
 *
 * @param cur_addr cur flash address
 *
 * @return next flash sector address
 */
static uint32_t get_next_flash_sec_addr(uint32_t cur_addr)
{
	size_t cur_sec_id = (cur_addr - log_area_start_addr) / EF_ERASE_MIN_SIZE;
	size_t sec_total_num = LOG_AREA_SIZE / EF_ERASE_MIN_SIZE;

	if (cur_sec_id + 1 >= sec_total_num) {
		/* return to ring head */
		return log_area_start_addr;
	} else
		return log_area_start_addr + (cur_sec_id + 1) * EF_ERASE_MIN_SIZE;
}

/**
 * Clean all log which in flash.
 *
 * @return result
 */
EfErrCode ef_log_clean(void)
{
	EfErrCode result = EF_NO_ERR;
	uint32_t write_addr = log_area_start_addr;

	/* clean address */
	log_start_addr = log_area_start_addr;
	log_end_addr = log_start_addr + LOG_SECTOR_HEADER_SIZE;
	/* erase log flash area */
	result = ef_port_erase(log_area_start_addr, LOG_AREA_SIZE);
	if (result != EF_NO_ERR)
		goto exit;
	/* setting first sector is USING */
	write_sector_status(write_addr, SECTOR_STATUS_USING);
	if (result != EF_NO_ERR)
		goto exit;
	write_addr += EF_ERASE_MIN_SIZE;
	/* add sector header */
	while (true) {
		write_sector_status(write_addr, SECTOR_STATUS_EMPUT);
		if (result != EF_NO_ERR)
			goto exit;
		write_addr += EF_ERASE_MIN_SIZE;
		if (write_addr >= log_area_start_addr + LOG_AREA_SIZE)
			break;
	}

exit:
	return result;
}

#endif /* EF_USING_LOG */
